home *** CD-ROM | disk | FTP | other *** search
/ SCI Games E3 2005 Press Kit (USA) / SCI Games E3 2005 Press Kit (USA).bin / runme_mac.swf / scripts / __Packages / mx / controls / MediaDisplay.as < prev    next >
Text File  |  2005-05-05  |  19KB  |  744 lines
  1. class mx.controls.MediaDisplay extends mx.core.UIComponent
  2. {
  3.    static var symbolName = "MediaDisplay";
  4.    static var symbolOwner = mx.controls.MediaDisplay;
  5.    var className = "MediaDisplay";
  6.    static var version = "2.0.1.78";
  7.    var clipParameters = {mediaType:"FLV",contentPath:"",totalTime:0,autoSize:true,autoPlay:true,initCuePointNames:new Array(),initCuePointTimes:new Array(),fps:30};
  8.    var _priorTime = 0;
  9.    var _priorBytesLoaded = 0;
  10.    var _scrubbing = false;
  11.    var _fireCuePoints = true;
  12.    var _enabled = true;
  13.    var makeVideoVisible = false;
  14.    function MediaDisplay()
  15.    {
  16.       super();
  17.    }
  18.    function init(Void)
  19.    {
  20.       this.initializeParameters();
  21.       var _loc3_ = this._width;
  22.       var _loc4_ = this._height;
  23.       this._deadPreview._visible = false;
  24.       super.init();
  25.       this.setSize(_loc3_,_loc4_,true);
  26.       this.initCuePoints();
  27.       this._startingTime = 0;
  28.       this._playingBeforeDisabled = false;
  29.       this._started = false;
  30.       this._sendCompleteEvent = false;
  31.       this._fullyLoaded = false;
  32.       this.makeVideoVisible = false;
  33.       this.tabEnabled = false;
  34.       this.tabChildren = false;
  35.       this._screenAccommodator = new mx.controls.streamingmedia.ScreenAccommodator(this);
  36.    }
  37.    function initializeParameters()
  38.    {
  39.       if(this.__get__mediaType() == null)
  40.       {
  41.          this.__set__mediaType("FLV");
  42.       }
  43.       if(this.__get__totalTime() == null)
  44.       {
  45.          this.__set__totalTime(0);
  46.       }
  47.       if(this.__get__contentPath() == null)
  48.       {
  49.          this.__set__contentPath("");
  50.       }
  51.       if(this.__get__autoPlay() == null)
  52.       {
  53.          this.__set__autoPlay(true);
  54.       }
  55.       if(this.__get__autoSize() == null)
  56.       {
  57.          this.__set__autoSize(true);
  58.       }
  59.       if(this.__get__aspectRatio() == null)
  60.       {
  61.          this.__set__aspectRatio(true);
  62.       }
  63.    }
  64.    function initCuePoints()
  65.    {
  66.       this._cuePoints = new Array();
  67.       var _loc2_ = 0;
  68.       while(_loc2_ < this.initCuePointNames.length && _loc2_ < this.initCuePointTimes.length)
  69.       {
  70.          this.addCuePoint(this.initCuePointNames[_loc2_],this.initCuePointTimes[_loc2_]);
  71.          _loc2_ = _loc2_ + 1;
  72.       }
  73.       delete this.initCuePointNames;
  74.       delete this.initCuePointTimes;
  75.       this._mostRecentCuePoint = undefined;
  76.    }
  77.    function initMedia(switchType)
  78.    {
  79.       if(this.isLivePreview())
  80.       {
  81.          return undefined;
  82.       }
  83.       var _loc2_ = this.__get__volume();
  84.       if(switchType)
  85.       {
  86.          this._playerImpl.stop();
  87.       }
  88.       if(this.isFLV())
  89.       {
  90.          if(this.isRtmp(this._contentPath))
  91.          {
  92.             this._playerImpl = new mx.controls.streamingmedia.RTMPPlayer(this._contentPath,mx.controls.streamingmedia.StreamingMediaConstants.FLV_MEDIA_TYPE,this._videoHolder,this._totalTime);
  93.          }
  94.          else
  95.          {
  96.             this._playerImpl = new mx.controls.streamingmedia.FLVPlayer(this._contentPath,this._videoHolder,this._totalTime);
  97.          }
  98.       }
  99.       else if(this.isMP3())
  100.       {
  101.          if(switchType)
  102.          {
  103.             this.releaseVideo();
  104.          }
  105.          if(this.isRtmp(this._contentPath))
  106.          {
  107.             this._playerImpl = new mx.controls.streamingmedia.RTMPPlayer(this._contentPath,mx.controls.streamingmedia.StreamingMediaConstants.MP3_MEDIA_TYPE,this._videoHolder,this._totalTime);
  108.          }
  109.          else
  110.          {
  111.             this.createEmptyMovieClip("_soundHolder",10);
  112.             this._playerImpl = new mx.controls.streamingmedia.MP3Player(this._contentPath,this._soundHolder);
  113.          }
  114.       }
  115.       if(_loc2_ != undefined)
  116.       {
  117.          this.__set__volume(_loc2_);
  118.       }
  119.       this.redraw(true);
  120.       this._playerImpl.removeAllListeners();
  121.       this._playerImpl.addListener(this);
  122.       this._started = false;
  123.       if(!switchType)
  124.       {
  125.          if(this._autoPlay)
  126.          {
  127.             this.play();
  128.          }
  129.          else
  130.          {
  131.             this.load();
  132.          }
  133.          this.poll(true);
  134.          if(this._pollId != null)
  135.          {
  136.             clearInterval(this._pollId);
  137.          }
  138.          this._pollId = setInterval(this,"poll",250);
  139.       }
  140.    }
  141.    function draw()
  142.    {
  143.       if(this.isFLV())
  144.       {
  145.          if(this.makeVideoVisible)
  146.          {
  147.             this._videoHolder._visible = true;
  148.             this.makeVideoVisible = false;
  149.          }
  150.          if(this._autoSize)
  151.          {
  152.             this.assignPreferredSize();
  153.          }
  154.          else if(this._aspectRatio)
  155.          {
  156.             var _loc4_ = this.__get__preferredWidth();
  157.             var _loc3_ = this.__get__preferredHeight();
  158.             var _loc2_ = Math.min(this.__get__width() / _loc4_,this.__get__height() / _loc3_);
  159.             this.setVideoDisplaySize(_loc2_ * _loc4_,_loc2_ * _loc3_);
  160.          }
  161.          else
  162.          {
  163.             this.setVideoDisplaySize(this.__get__width(),this.__get__height());
  164.          }
  165.       }
  166.    }
  167.    function setVideoDisplaySize(w, h)
  168.    {
  169.       if(this.isFLV())
  170.       {
  171.          var _loc2_ = this._videoHolder._video;
  172.          _loc2_._width = w;
  173.          _loc2_._height = h;
  174.          _loc2_._x = (this.__get__width() - _loc2_._width) / 2;
  175.          _loc2_._y = (this.__get__height() - _loc2_._height) / 2;
  176.       }
  177.    }
  178.    function get videoWidth()
  179.    {
  180.       var _loc2_ = undefined;
  181.       if(this.isMP3())
  182.       {
  183.          _loc2_ = 0;
  184.       }
  185.       else
  186.       {
  187.          _loc2_ = this._videoHolder._video._width;
  188.       }
  189.       return _loc2_;
  190.    }
  191.    function get videoHeight()
  192.    {
  193.       var _loc2_ = undefined;
  194.       if(this.isMP3())
  195.       {
  196.          _loc2_ = 0;
  197.       }
  198.       else
  199.       {
  200.          _loc2_ = this._videoHolder._video._height;
  201.       }
  202.       return _loc2_;
  203.    }
  204.    function get preferredWidth()
  205.    {
  206.       var _loc2_ = undefined;
  207.       if(this.isMP3())
  208.       {
  209.          _loc2_ = 0;
  210.       }
  211.       else
  212.       {
  213.          _loc2_ = this._videoHolder._video.width;
  214.       }
  215.       return _loc2_;
  216.    }
  217.    function get preferredHeight()
  218.    {
  219.       var _loc2_ = undefined;
  220.       if(this.isMP3())
  221.       {
  222.          _loc2_ = 0;
  223.       }
  224.       else
  225.       {
  226.          _loc2_ = this._videoHolder._video.height;
  227.       }
  228.       return _loc2_;
  229.    }
  230.    function assignPreferredSize()
  231.    {
  232.       this.setVideoDisplaySize(this.__get__preferredWidth(),this.__get__preferredHeight(),true);
  233.    }
  234.    function handlePlayer(player, status)
  235.    {
  236.       if(status == "start" || status == "resizeVideo")
  237.       {
  238.          if(!(this._parent instanceof mx.controls.MediaPlayback))
  239.          {
  240.             this.makeVideoVisible = true;
  241.             this.draw();
  242.          }
  243.          if(this._started)
  244.          {
  245.             var _loc2_ = {target:this,type:"resizeVideo"};
  246.             this.dispatchEvent(_loc2_);
  247.          }
  248.          else
  249.          {
  250.             _loc2_ = {target:this,type:"start"};
  251.             this.dispatchEvent(_loc2_);
  252.             if(this.isRtmp(this._contentPath))
  253.             {
  254.                _loc2_ = {target:this,type:"progress"};
  255.                this.dispatchEvent(_loc2_);
  256.             }
  257.             this._started = true;
  258.          }
  259.       }
  260.       else if(status == "complete")
  261.       {
  262.          this._sendCompleteEvent = true;
  263.       }
  264.    }
  265.    function toString()
  266.    {
  267.       return "MediaDisplay: media=" + this._contentPath;
  268.    }
  269.    function load()
  270.    {
  271.       this._playerImpl.load();
  272.    }
  273.    function play(startingPoint)
  274.    {
  275.       if(startingPoint != undefined)
  276.       {
  277.          this._startingTime = startingPoint;
  278.       }
  279.       if(this.__get__enabled())
  280.       {
  281.          this._playerImpl.play(startingPoint);
  282.       }
  283.       else
  284.       {
  285.          this._playingBeforeDisabled = true;
  286.       }
  287.    }
  288.    function pause()
  289.    {
  290.       this._playerImpl.pause();
  291.    }
  292.    function stop()
  293.    {
  294.       this._playerImpl.stop();
  295.    }
  296.    function get autoSize()
  297.    {
  298.       return this._autoSize;
  299.    }
  300.    function set autoSize(flag)
  301.    {
  302.       if(this._autoSize != flag)
  303.       {
  304.          this._autoSize = flag;
  305.          this.invalidate();
  306.       }
  307.    }
  308.    function get aspectRatio()
  309.    {
  310.       return this._aspectRatio;
  311.    }
  312.    function set aspectRatio(flag)
  313.    {
  314.       if(this._aspectRatio != flag)
  315.       {
  316.          this._aspectRatio = flag;
  317.          this.invalidate();
  318.       }
  319.    }
  320.    function get autoPlay()
  321.    {
  322.       return this._autoPlay;
  323.    }
  324.    function set autoPlay(flag)
  325.    {
  326.       this._autoPlay = flag;
  327.    }
  328.    function get playheadTime()
  329.    {
  330.       return this._playerImpl.getPlayheadTime();
  331.    }
  332.    function set playheadTime(position)
  333.    {
  334.       if(position != undefined)
  335.       {
  336.          this._startingTime = position;
  337.       }
  338.       this._playerImpl.setPlayheadTime(position);
  339.    }
  340.    function get contentPath()
  341.    {
  342.       return this._contentPath;
  343.    }
  344.    function set contentPath(aUrl)
  345.    {
  346.       this.setMedia(aUrl);
  347.    }
  348.    function setMedia(aUrl, aType)
  349.    {
  350.       this._fireCuePoints = false;
  351.       if(aType == null)
  352.       {
  353.          aType = this.deduceMediaType(aUrl);
  354.       }
  355.       else if(aType != mx.controls.streamingmedia.StreamingMediaConstants.FLV_MEDIA_TYPE && aType != mx.controls.streamingmedia.StreamingMediaConstants.MP3_MEDIA_TYPE)
  356.       {
  357.       }
  358.       var _loc5_ = this._mediaType;
  359.       this._mediaType = aType;
  360.       var _loc7_ = this.isRtmp(this._contentPath);
  361.       var _loc6_ = this.isRtmp(aUrl);
  362.       this._contentPath = aUrl;
  363.       this._fullyLoaded = false;
  364.       this._startingTime = 0;
  365.       if(!this.isLivePreview())
  366.       {
  367.          if(this._contentPath == "")
  368.          {
  369.             this.releaseVideo();
  370.          }
  371.          else if(this._playerImpl == null)
  372.          {
  373.             this.initMedia();
  374.          }
  375.          else if(_loc5_ != this._mediaType || _loc7_ != _loc6_)
  376.          {
  377.             var _loc4_ = this._playerImpl.isPlaying();
  378.             this.initMedia(true);
  379.             if(_loc4_)
  380.             {
  381.                this._playerImpl.play(0);
  382.             }
  383.             else
  384.             {
  385.                this._playerImpl.load();
  386.             }
  387.          }
  388.          else
  389.          {
  390.             this._playerImpl.setMediaUrl(aUrl);
  391.             this._started = false;
  392.          }
  393.       }
  394.    }
  395.    function deduceMediaType(aUrl)
  396.    {
  397.       var _loc2_ = aUrl.substr(-3);
  398.       if(_loc2_ == "flv" || _loc2_ == "FLV")
  399.       {
  400.          return "FLV";
  401.       }
  402.       if(_loc2_ == "mp3" || _loc2_ == "MP3")
  403.       {
  404.          return "MP3";
  405.       }
  406.       return this._mediaType;
  407.    }
  408.    function releaseVideo()
  409.    {
  410.       this._playerImpl.close();
  411.       this._playerImpl = null;
  412.    }
  413.    function isLivePreview()
  414.    {
  415.       return _root.contents.obj != null;
  416.    }
  417.    function get volume()
  418.    {
  419.       return this._playerImpl.getVolume();
  420.    }
  421.    function set volume(aVol)
  422.    {
  423.       this._playerImpl.setVolume(aVol);
  424.    }
  425.    function get playing()
  426.    {
  427.       return this._playerImpl.isPlaying();
  428.    }
  429.    function get bytesLoaded()
  430.    {
  431.       return this._playerImpl.getMediaBytesLoaded();
  432.    }
  433.    function get bytesTotal()
  434.    {
  435.       return this._playerImpl.getMediaBytesTotal();
  436.    }
  437.    function isFLV()
  438.    {
  439.       return this._mediaType == mx.controls.streamingmedia.StreamingMediaConstants.FLV_MEDIA_TYPE;
  440.    }
  441.    function isMP3()
  442.    {
  443.       return this._mediaType == mx.controls.streamingmedia.StreamingMediaConstants.MP3_MEDIA_TYPE;
  444.    }
  445.    function get mediaType()
  446.    {
  447.       return this._mediaType;
  448.    }
  449.    function set mediaType(aType)
  450.    {
  451.       this._mediaType = aType;
  452.    }
  453.    function get totalTime()
  454.    {
  455.       var _loc2_ = undefined;
  456.       if(this._playerImpl == null)
  457.       {
  458.          _loc2_ = this._totalTime;
  459.       }
  460.       else
  461.       {
  462.          _loc2_ = this._playerImpl.getTotalTime();
  463.       }
  464.       return _loc2_;
  465.    }
  466.    function set totalTime(aTime)
  467.    {
  468.       this._totalTime = aTime;
  469.       if(this._playerImpl instanceof mx.controls.streamingmedia.FLVPlayer)
  470.       {
  471.          this._playerImpl.setTotalTime(aTime);
  472.       }
  473.       else if(this._playerImpl instanceof mx.controls.streamingmedia.RTMPPlayer)
  474.       {
  475.          this._playerImpl.setTotalTime(aTime);
  476.       }
  477.    }
  478.    function getCuePoints()
  479.    {
  480.       return this._cuePoints;
  481.    }
  482.    function get cuePoints()
  483.    {
  484.       return this.getCuePoints();
  485.    }
  486.    function setCuePoints(cp)
  487.    {
  488.       this._cuePoints = cp;
  489.       var _loc2_ = 0;
  490.       while(_loc2_ < this._cuePoints.length)
  491.       {
  492.          this._cuePoints[_loc2_].display = this;
  493.          _loc2_ = _loc2_ + 1;
  494.       }
  495.    }
  496.    function set cuePoints(cp)
  497.    {
  498.       this.setCuePoints(cp);
  499.    }
  500.    function getCuePoint(pointName)
  501.    {
  502.       var _loc3_ = null;
  503.       var _loc2_ = this.getCuePointIndex(pointName);
  504.       if(_loc2_ > -1)
  505.       {
  506.          _loc3_ = this._cuePoints[_loc2_];
  507.       }
  508.       return _loc3_;
  509.    }
  510.    function addCuePoint(aName, aTime)
  511.    {
  512.       var _loc2_ = new mx.controls.streamingmedia.CuePoint(aName,aTime);
  513.       this.addCuePointObject(_loc2_);
  514.    }
  515.    function addCuePointObject(aCuePoint)
  516.    {
  517.       aCuePoint.display = this;
  518.       this._cuePoints.push(aCuePoint);
  519.    }
  520.    function removeCuePoint(aCuePoint)
  521.    {
  522.       var _loc2_ = this.getCuePointIndex(aCuePoint.name);
  523.       if(_loc2_ > -1)
  524.       {
  525.          this._cuePoints.splice(_loc2_,1);
  526.       }
  527.    }
  528.    function removeAllCuePoints()
  529.    {
  530.       this._cuePoints.length = 0;
  531.       this._mostRecentCuePoint = undefined;
  532.    }
  533.    function get mostRecentCuePoint()
  534.    {
  535.       return this._mostRecentCuePoint;
  536.    }
  537.    function get mostRecentCuePointName()
  538.    {
  539.       return this._mostRecentCuePoint.name;
  540.    }
  541.    function get mostRecentCuePointTime()
  542.    {
  543.       return this._mostRecentCuePoint.time;
  544.    }
  545.    function handleEvent(ev)
  546.    {
  547.       if(ev.type == "click" && ev.detail == "play")
  548.       {
  549.          this.handlePlayEvent(ev);
  550.       }
  551.       else if(ev.type == "click" && ev.detail == "pause")
  552.       {
  553.          this.handlePauseEvent(ev);
  554.       }
  555.       else if(ev.type == "playheadChange")
  556.       {
  557.          this.handlePlayheadChangeEvent(ev);
  558.       }
  559.       else if(ev.type == "volume")
  560.       {
  561.          this.handleVolumeEvent(ev);
  562.       }
  563.       else if(ev.type == "scrubbing")
  564.       {
  565.          this.handleScrubbingEvent(ev);
  566.       }
  567.       else
  568.       {
  569.          this.handleUnrecognizedEvent(ev);
  570.       }
  571.    }
  572.    function handlePlayEvent(ev)
  573.    {
  574.       this.play();
  575.    }
  576.    function handleStopEvent(ev)
  577.    {
  578.       this.stop();
  579.    }
  580.    function handlePauseEvent(ev)
  581.    {
  582.       this.pause();
  583.    }
  584.    function handleRewindEvent(ev)
  585.    {
  586.       this.__set__playheadTime(0);
  587.    }
  588.    function handleFastForwardEvent(ev)
  589.    {
  590.       var _loc2_ = this.__get__totalTime();
  591.       this.__set__playheadTime(_loc2_);
  592.    }
  593.    function handlePlayheadChangeEvent(ev)
  594.    {
  595.       var _loc3_ = ev.detail;
  596.       var _loc2_ = _loc3_ / 100 * this.__get__totalTime();
  597.       this._fireCuePoints = this._scrubbing;
  598.       this.__set__playheadTime(_loc2_);
  599.    }
  600.    function handleVolumeEvent(ev)
  601.    {
  602.       var _loc2_ = ev.detail;
  603.       this.__set__volume(_loc2_);
  604.    }
  605.    function handleScrubbingEvent(ev)
  606.    {
  607.       this._scrubbing = ev.detail;
  608.    }
  609.    function handleUnrecognizedEvent(ev)
  610.    {
  611.    }
  612.    function getCuePointIndex(pointName)
  613.    {
  614.       var _loc3_ = -1;
  615.       var _loc2_ = 0;
  616.       while(_loc2_ < this._cuePoints.length && _loc3_ == -1)
  617.       {
  618.          if(this._cuePoints[_loc2_].name == pointName)
  619.          {
  620.             _loc3_ = _loc2_;
  621.          }
  622.          _loc2_ = _loc2_ + 1;
  623.       }
  624.       return _loc3_;
  625.    }
  626.    function poll(first)
  627.    {
  628.       var _loc4_ = this.__get__playheadTime();
  629.       var _loc8_ = this.__get__bytesLoaded();
  630.       if(_loc4_ != this._priorTime)
  631.       {
  632.          if(this._mediaType == "MP3" && this._playerImpl.isPlaying() && !this._started)
  633.          {
  634.             this._playerImpl.playStarted();
  635.             var _loc9_ = this.__get__playheadTime();
  636.             if(this._startingTime - 0.1 < _loc9_ && _loc9_ < this._startingTime + 0.1)
  637.             {
  638.                this._started = true;
  639.                var _loc10_ = {target:this,type:"start"};
  640.                this.dispatchEvent(_loc10_);
  641.             }
  642.          }
  643.          _loc10_ = {type:"change",target:this};
  644.          this.dispatchEvent(_loc10_);
  645.       }
  646.       var _loc7_ = false;
  647.       if(!this._fullyLoaded && this.__get__bytesLoaded() >= this.__get__bytesTotal() - 100)
  648.       {
  649.          this._fullyLoaded = true;
  650.          this._playerImpl.mediaLoaded();
  651.          _loc7_ = true;
  652.       }
  653.       else if(first || _loc8_ != this._priorBytesLoaded)
  654.       {
  655.          _loc7_ = true;
  656.       }
  657.       if(_loc7_)
  658.       {
  659.          _loc10_ = {type:"progress",target:this};
  660.          this.dispatchEvent(_loc10_);
  661.       }
  662.       var _loc2_ = null;
  663.       var _loc3_ = 0;
  664.       while(this._fireCuePoints && _loc3_ < this._cuePoints.length)
  665.       {
  666.          _loc2_ = this._cuePoints[_loc3_];
  667.          if(this._priorTime < _loc2_.time && _loc4_ >= _loc2_.time || this._priorTime > _loc2_.time && _loc4_ <= _loc2_.time)
  668.          {
  669.             this._mostRecentCuePoint = _loc2_;
  670.             _loc10_ = {type:"cuePoint",target:this,cuePointName:_loc2_.name,cuePointTime:_loc2_.time};
  671.             this.dispatchEvent(_loc10_);
  672.          }
  673.          _loc3_ = _loc3_ + 1;
  674.       }
  675.       this._fireCuePoints = true;
  676.       if(this._sendCompleteEvent)
  677.       {
  678.          this._sendCompleteEvent = false;
  679.          _loc10_ = {type:"complete",target:this};
  680.          this.dispatchEvent(_loc10_);
  681.       }
  682.       this._priorTime = _loc4_;
  683.       this._priorBytesLoaded = _loc8_;
  684.    }
  685.    function isRtmp(mediaUrl)
  686.    {
  687.       if(mediaUrl != null)
  688.       {
  689.          var _loc1_ = undefined;
  690.          _loc1_ = mediaUrl.toLowerCase();
  691.          return _loc1_.indexOf("rtmp") == 0;
  692.       }
  693.       return false;
  694.    }
  695.    function associateController(c)
  696.    {
  697.       c.addEventListener("click",this);
  698.       c.addEventListener("playheadChange",this);
  699.       c.addEventListener("volume",this);
  700.       c.addEventListener("scrubbing",this);
  701.       this.addEventListener("change",c);
  702.       this.addEventListener("progress",c);
  703.       this.addEventListener("complete",c);
  704.    }
  705.    function setSize(w, h, noEvent)
  706.    {
  707.       super.setSize(w,h,noEvent);
  708.       this.invalidate();
  709.    }
  710.    function get enabled()
  711.    {
  712.       return this._enabled;
  713.    }
  714.    function set enabled(is)
  715.    {
  716.       if(this._enabled == is)
  717.       {
  718.          return undefined;
  719.       }
  720.       this._enabled = is;
  721.       if(is)
  722.       {
  723.          if(this._playingBeforeDisabled)
  724.          {
  725.             this.play();
  726.             this._playingBeforeDisabled = false;
  727.          }
  728.       }
  729.       else
  730.       {
  731.          this._playingBeforeDisabled = this.playing;
  732.          if(this._playingBeforeDisabled && this._playerImpl instanceof mx.controls.streamingmedia.MP3Player)
  733.          {
  734.             this._playingBeforeDisabled = !this._playerImpl.willStop();
  735.          }
  736.          this.pause();
  737.       }
  738.    }
  739.    function onUnload()
  740.    {
  741.       this._playerImpl.close();
  742.    }
  743. }
  744.